On Algebraic Decoding of qq-ary Reed-Muller and Product-Reed-Solomon Codes

We consider a list decoding algorithm recently proposed by Pellikaan-Wu \cite{PW2005} for $q$-ary Reed-Muller codes $\mathcal{RM}_q(\ell, m, n)$ of length $n \leq q^m$ when $\ell \leq q$. A simple and easily accessible correctness proof is given which shows that this algorithm achieves a relative error-correction radius of $\tau \leq (1 - \sqrt{{\ell q^{m-1}}/{n}})$. This is an improvement over the proof using one-point Algebraic-Geometric codes given in \cite{PW2005}. The described algorithm can be adapted to decode Product-Reed-Solomon codes. We then propose a new low complexity recursive algebraic decoding algorithm for Reed-Muller and Product-Reed-Solomon codes. Our algorithm achieves a relative error correction radius of $\tau \leq \prod_{i=1}^m (1 - \sqrt{k_i/q})$. This technique is then proved to outperform the Pellikaan-Wu method in both complexity and error correction radius over a wide range of code rates.Comment: 5 pages, 5 figures, to be presented at 2007 IEEE International Symposium on Information Theory, Nice, France (ISIT 2007

BB-ML: Basic Block Performance Prediction using Machine Learning Techniques

Recent years have seen the adoption of Machine Learning (ML) techniques to predict the performance of large-scale applications, mostly at a coarse level. In contrast, we propose to use ML techniques for performance prediction at a much finer granularity, namely at the Basic Block (BB) level, which are single entry, single exit code blocks that are used for analysis by the compilers to break down a large code into manageable pieces. We extrapolate the basic block execution counts of GPU applications and use them for predicting the performance for large input sizes from the counts of smaller input sizes. We train a Poisson Neural Network (PNN) model using random input values as well as the lowest input values of the application to learn the relationship between inputs and basic block counts. Experimental results show that the model can accurately predict the basic block execution counts of 16 GPU benchmarks. We achieve an accuracy of 93.5% in extrapolating the basic block counts for large input sets when trained on smaller input sets and an accuracy of 97.7% in predicting basic block counts on random instances. In a case study, we apply the ML model to CUDA GPU benchmarks for performance prediction across a spectrum of applications. We use a variety of metrics for evaluation, including global memory requests and the active cycles of tensor cores, ALU, and FMA units. Results demonstrate the model's capability of predicting the performance of large datasets with an average error rate of 0.85% and 0.17% for global and shared memory requests, respectively. Additionally, to address the utilization of the main functional units in Ampere architecture GPUs, we calculate the active cycles for tensor cores, ALU, FMA, and FP64 units and achieve an average error of 2.3% and 10.66% for ALU and FMA units while the maximum observed error across all tested applications and units reaches 18.5%.Comment: Accepted at the 29th IEEE International Conference on Parallel and Distributed Systems (ICPADS 2023

Quantum Algorithm Implementations for Beginners

As quantum computers become available to the general public, the need has arisen to train a cohort of quantum programmers, many of whom have been developing classical computer programs for most of their careers. While currently available quantum computers have less than 100 qubits, quantum computing hardware is widely expected to grow in terms of qubit count, quality, and connectivity. This review aims to explain the principles of quantum programming, which are quite different from classical programming, with straightforward algebra that makes understanding of the underlying fascinating quantum mechanical principles optional. We give an introduction to quantum computing algorithms and their implementation on real quantum hardware. We survey 20 different quantum algorithms, attempting to describe each in a succinct and self-contained fashion. We show how these algorithms can be implemented on IBM's quantum computer, and in each case, we discuss the results of the implementation with respect to differences between the simulator and the actual hardware runs. This article introduces computer scientists, physicists, and engineers to quantum algorithms and provides a blueprint for their implementations

Graphical models for coding and computation

High data rate applications are beginning to push the limits of communication and computer systems. While there is a need to design good codes and decoders, it is also important to analyze and optimize the decoding algorithms so that they do not use up too much resources. Graphical behavioral models of codes and sequential computers can serve as the common platform for accomplishing both tasks. In this thesis we use closely related graphical models such as factor graphs and branching programs to analyze convergence and performance of iterative decoding algorithms and time-space complexity of functions and decision problems related to codes. In the first part we look at graph realizations of codes. We give a construction of an analog coding scheme on graphs with an efficient iterative decoder for any given bandwidth expansion over unity. This code does not exhibit the well- known threshold effect and has a graceful degradation of performance with increasing noise -- thus disproving a widely held belief that no single practical coding scheme can achieve this. We then analyze the iterative hard- decision decoding scheme of Gallager applied to arbitrary linear codes, and derive probabilistic necessary and sufficient conditions for progressive improvement of the codeword estimates. Finally we analyze the iterative decoding of product codes using bounded distance component decoders and derive the exact probability of error evolution rules, assuming statistically independent errors. In the second part we consider the general Branching Program (BP) model for non-uniform sequential computation -- perhaps second in importance only to Turing machines. We consider the time-space complexity of encoding arbitrary codes on a time-restricted BP model and derive a sharpened version of the Bazzi-Mitter minimum distance bound. Using a probabilistic technique we then obtain a new quadratic time-space tradeoff for syndrome vector computation of linear codes on a unrestricted BP model and use it to prove a conjecture due to Bazzi-Mitter for self-dual codes. Next we extend our probabilistic techniques to deal with decision branching programs and derive the first quadratic time-space tradeoff for a read restricted decision BP model. The minimum distance bounds along with deep new connections between properties of some well known properties of algebraic codes are then used to give tight time-space tradeoffs for computing and verifying several fundamental operations. These include finite-field multiplication, integer multiplication, circular convolution, matrix-vector product and discrete Fourier transform. Many of these tight bounds are new and the rest match the best previous known bounds. In the last part we consider the problem of estimating the Bayes risk in multiple hypothesis testing. We significantly improve the classical equivocation bound due to Renyi. We also derive a lower bound on equivocation and an upper bound on mutual information of most capacity achieving codes on memoryless channels using a random coding argumen